package educar.models;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;


import educar.db.DbConnection;
import educar.db.JPA;

public class Alumno extends Persona
{

    private static JPA jpa = new JPA();
    private int codigo;

    private Alumno(String ape, String nom, String dniP,int codigo,String email, String telPersonal, String pais, String provincia, String ciudad, String direccion, String foto )
    {
        super(ape, nom, dniP,email,telPersonal,pais, provincia, ciudad,direccion,foto);
        this.codigo = codigo;
    }

    public Alumno(String ape, String nom, String dniP,String email, String telPersonal, String pais, String provincia, String ciudad, String direccion, String foto )
    {
        super(ape, nom, dniP,email,telPersonal,pais, provincia, ciudad,direccion,foto) ;
    }

    public boolean inscribir(Materia m)
    {
        return inscribir(m.getCodigo());
    }

    public boolean inscribir(String codigoMateria)
    {
        boolean result = true;
        String[] columns = { "codigoMat", "dniAlu"};

        PreparedStatement stm = jpa.newRecord(DbConnection.bd+".inscripcion", columns);
        try
        {
            stm.setString(1, codigoMateria);
            stm.setString(2, getDni());
        }
        catch (SQLException e)
        {
            result = false;
        }

        result = jpa.create(stm) && result;

        return result;
    }

    private PreparedStatement prepararSentencia()
    {
        String[] columns = { "dniAlumno", "numAlumno"};

        PreparedStatement stm = jpa.newRecord(DbConnection.bd+".alumno", columns);
        try
        {
            stm.setString(1, super.getDni());
            stm.setString(2, null);
        }
        catch (SQLException e)
        {
            e.printStackTrace();

        }
        return stm;
    }

    public boolean save()
    {
        super.save();
        try
        {
            getAlumnoByDni(getDni());
            return false;
        }
        catch (alumnoNotFound e1)
        {
            jpa.create(prepararSentencia());
            actualizarNumAlumnoAlMaximo();
            return true;
        }
    }


    public static Alumno getAlumnoByDni(String dni) throws alumnoNotFound
    {
        Alumno alumno = null;
        ResultSet rs = null;
        Persona p = null;

        rs = jpa.getByField("alumno", "dniAlumno", dni);

        try
        {
            if (rs.next())
            {
                try
                {
                    p = Persona.getPersonaByDni(dni);
                }
                catch (personaNotFound e)
                {
                    throw new alumnoNotFound();
                }
                alumno = new Alumno(p.getApellido(), p.getNombre(), p.getDni(), rs.getInt(2),p.getEmail(),p.getTelPersonal(),p.getPais(),p.getProvincia(),p.getCiudad(),p.getDireccion(),p.getFoto());
            }
            else
            {
                throw new alumnoNotFound();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }

        return alumno;
    }

    public static Alumno getAlumnoByCodigo(int codigo) throws alumnoNotFound
    {
        Alumno alumno = null;
        ResultSet rs = null;
        Persona p = null;

        rs = jpa.getByField("alumno", "numAlumno", String.valueOf(codigo));

        try
        {
            if (rs.next())
            {
                try
                {
                    p = Persona.getPersonaByDni(rs.getString(1));
                }
                catch (personaNotFound e)
                {
                    throw new alumnoNotFound();
                }
                alumno = new Alumno(p.getApellido(), p.getNombre(), p.getDni(), rs.getInt(2),p.getEmail(),p.getTelPersonal(),p.getPais(),p.getProvincia(),p.getCiudad(),p.getDireccion(),p.getFoto());
            }
            else
            {
                throw new alumnoNotFound();
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }

        return alumno;
    }


    public static LinkedList<Alumno> getAll() throws alumnoNotFound
    {
        Persona p = null;
        Alumno a = null;
        ResultSet rs = null;
        LinkedList<Alumno> alumnos = new LinkedList<Alumno>();
        rs = jpa.showAll("alumno");
        try
        {
            while (rs.next())
            {
                try
                {
                    p = Persona.getPersonaByDni(rs.getString(1));
                }
                catch (personaNotFound e)
                {
                    throw new alumnoNotFound();
                }
                a = new Alumno(p.getApellido(), p.getNombre(), p.getDni(), rs.getInt(2),p.getEmail(),p.getTelPersonal(),p.getPais(),p.getProvincia(),p.getCiudad(),p.getDireccion(),p.getFoto());

                alumnos.add(a);
            }

        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }

        return alumnos;
    }

    public void destroy()
    {
        jpa.destroy("alumno", "dniAlumno", getDni());
    }

    public void destroyPersona()
    {
        //el motor de bd automáticamente borra la persona de la tabla alumno
        super.destroy();
    }

    //para utilizar al guardar un alumno en la base de datos
    //y obtener el codigo que le fue asignado en el objeto
    //utilizar sólo inmediatamente despues de guardar en la base de datos
    private void actualizarNumAlumnoAlMaximo()
    {
        ResultSet rs = jpa.showMaxColumn("alumno", "numAlumno");
        try
        {
            if (rs.next())
            {
                this.codigo = rs.getInt(1);
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
    }

    public static String[] getAllArray()
    {
        String[] alumnos = null;
        try
        {
            LinkedList<Alumno> a = getAll(); //TODO: pedir unicamente la columa nombre a la db
            alumnos = new String[a.size()];
            for (int i = 0; i < a.size(); i++)
                alumnos[i] = a.get(i).toString();
        }
        catch (alumnoNotFound e)
        {
            alumnos = new String[0];
        }

        return alumnos;
    }

    public LinkedList<Materia> getAllMateriasYaInscripto()
    {
        ResultSet rs = null;
        LinkedList<Materia> materias = new LinkedList<Materia>();

        rs = jpa.getByField("inscripcion", "dniAlu", getDni());

        try
        {
            while (rs.next())
            {
                try
                {
                    Materia m = Materia.getMateriabyCodigo(rs.getString(1));
                    materias.add(m);
                }
                catch (materiaNotFound e)
                {}
            }
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }

        return materias;
    }

    public LinkedList<Actividad> getAllActividades()
    {
        LinkedList<Actividad> actividades = new LinkedList<Actividad>();
        LinkedList<Materia> materias = getAllMateriasYaInscripto();

        for (int i = 0; i < materias.size(); i++)
            actividades.addAll(materias.get(i).getAllActividades());

        return actividades;
    }

    public String[] getAllActividadesArray()
    {
        LinkedList<Actividad> l = getAllActividades();
        String[] actividades = new String[l.size()];
        for (int i = 0; i < l.size(); i++)
            actividades[i] = l.get(i).toString();

        return actividades;
    }

    public String[] getAllMateriasInscripto()
    {
        LinkedList<Materia> l = getAllMateriasYaInscripto();
        String[] materias = new String[l.size()];
        for (int i = 0; i < l.size(); i++)
            materias[i] = l.get(i).toString();

        return materias;
    }


    public String getCodigo()
    {
        return String.valueOf(this.codigo);
    }
}
